package com.ssish.saas.eccs.model;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class PlanConditionExample {
    protected String orderByClause;

    protected boolean distinct;

    protected List<Criteria> oredCriteria;

    public PlanConditionExample() {
        oredCriteria = new ArrayList<Criteria>();
    }

    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }

    public String getOrderByClause() {
        return orderByClause;
    }

    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }

    public boolean isDistinct() {
        return distinct;
    }

    public List<Criteria> getOredCriteria() {
        return oredCriteria;
    }

    public void or(Criteria criteria) {
        oredCriteria.add(criteria);
    }

    public Criteria or() {
        Criteria criteria = createCriteriaInternal();
        oredCriteria.add(criteria);
        return criteria;
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }
        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        Criteria criteria = new Criteria();
        return criteria;
    }

    public void clear() {
        oredCriteria.clear();
        orderByClause = null;
        distinct = false;
    }

    protected abstract static class GeneratedCriteria {
        protected List<Criterion> criteria;

        protected GeneratedCriteria() {
            super();
            criteria = new ArrayList<Criterion>();
        }

        public boolean isValid() {
            return criteria.size() > 0;
        }

        public List<Criterion> getAllCriteria() {
            return criteria;
        }

        public List<Criterion> getCriteria() {
            return criteria;
        }

        protected void addCriterion(String condition) {
            if (condition == null) {
                throw new RuntimeException("Value for condition cannot be null");
            }
            criteria.add(new Criterion(condition));
        }

        protected void addCriterion(String condition, Object value, String property) {
            if (value == null) {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value));
        }

        protected void addCriterion(String condition, Object value1, Object value2, String property) {
            if (value1 == null || value2 == null) {
                throw new RuntimeException("Between values for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value1, value2));
        }

        public Criteria andPlanCodeIsNull() {
            addCriterion("PLAN_CODE is null");
            return (Criteria) this;
        }

        public Criteria andPlanCodeIsNotNull() {
            addCriterion("PLAN_CODE is not null");
            return (Criteria) this;
        }

        public Criteria andPlanCodeEqualTo(String value) {
            addCriterion("PLAN_CODE =", value, "planCode");
            return (Criteria) this;
        }

        public Criteria andPlanCodeNotEqualTo(String value) {
            addCriterion("PLAN_CODE <>", value, "planCode");
            return (Criteria) this;
        }

        public Criteria andPlanCodeGreaterThan(String value) {
            addCriterion("PLAN_CODE >", value, "planCode");
            return (Criteria) this;
        }

        public Criteria andPlanCodeGreaterThanOrEqualTo(String value) {
            addCriterion("PLAN_CODE >=", value, "planCode");
            return (Criteria) this;
        }

        public Criteria andPlanCodeLessThan(String value) {
            addCriterion("PLAN_CODE <", value, "planCode");
            return (Criteria) this;
        }

        public Criteria andPlanCodeLessThanOrEqualTo(String value) {
            addCriterion("PLAN_CODE <=", value, "planCode");
            return (Criteria) this;
        }

        public Criteria andPlanCodeLike(String value) {
            addCriterion("PLAN_CODE like", value, "planCode");
            return (Criteria) this;
        }

        public Criteria andPlanCodeNotLike(String value) {
            addCriterion("PLAN_CODE not like", value, "planCode");
            return (Criteria) this;
        }

        public Criteria andPlanCodeIn(List<String> values) {
            addCriterion("PLAN_CODE in", values, "planCode");
            return (Criteria) this;
        }

        public Criteria andPlanCodeNotIn(List<String> values) {
            addCriterion("PLAN_CODE not in", values, "planCode");
            return (Criteria) this;
        }

        public Criteria andPlanCodeBetween(String value1, String value2) {
            addCriterion("PLAN_CODE between", value1, value2, "planCode");
            return (Criteria) this;
        }

        public Criteria andPlanCodeNotBetween(String value1, String value2) {
            addCriterion("PLAN_CODE not between", value1, value2, "planCode");
            return (Criteria) this;
        }

        public Criteria andCorpCodeIsNull() {
            addCriterion("CORP_CODE is null");
            return (Criteria) this;
        }

        public Criteria andCorpCodeIsNotNull() {
            addCriterion("CORP_CODE is not null");
            return (Criteria) this;
        }

        public Criteria andCorpCodeEqualTo(String value) {
            addCriterion("CORP_CODE =", value, "corpCode");
            return (Criteria) this;
        }

        public Criteria andCorpCodeNotEqualTo(String value) {
            addCriterion("CORP_CODE <>", value, "corpCode");
            return (Criteria) this;
        }

        public Criteria andCorpCodeGreaterThan(String value) {
            addCriterion("CORP_CODE >", value, "corpCode");
            return (Criteria) this;
        }

        public Criteria andCorpCodeGreaterThanOrEqualTo(String value) {
            addCriterion("CORP_CODE >=", value, "corpCode");
            return (Criteria) this;
        }

        public Criteria andCorpCodeLessThan(String value) {
            addCriterion("CORP_CODE <", value, "corpCode");
            return (Criteria) this;
        }

        public Criteria andCorpCodeLessThanOrEqualTo(String value) {
            addCriterion("CORP_CODE <=", value, "corpCode");
            return (Criteria) this;
        }

        public Criteria andCorpCodeLike(String value) {
            addCriterion("CORP_CODE like", value, "corpCode");
            return (Criteria) this;
        }

        public Criteria andCorpCodeNotLike(String value) {
            addCriterion("CORP_CODE not like", value, "corpCode");
            return (Criteria) this;
        }

        public Criteria andCorpCodeIn(List<String> values) {
            addCriterion("CORP_CODE in", values, "corpCode");
            return (Criteria) this;
        }

        public Criteria andCorpCodeNotIn(List<String> values) {
            addCriterion("CORP_CODE not in", values, "corpCode");
            return (Criteria) this;
        }

        public Criteria andCorpCodeBetween(String value1, String value2) {
            addCriterion("CORP_CODE between", value1, value2, "corpCode");
            return (Criteria) this;
        }

        public Criteria andCorpCodeNotBetween(String value1, String value2) {
            addCriterion("CORP_CODE not between", value1, value2, "corpCode");
            return (Criteria) this;
        }

        public Criteria andLimitCodeIsNull() {
            addCriterion("LIMIT_CODE is null");
            return (Criteria) this;
        }

        public Criteria andLimitCodeIsNotNull() {
            addCriterion("LIMIT_CODE is not null");
            return (Criteria) this;
        }

        public Criteria andLimitCodeEqualTo(String value) {
            addCriterion("LIMIT_CODE =", value, "limitCode");
            return (Criteria) this;
        }

        public Criteria andLimitCodeNotEqualTo(String value) {
            addCriterion("LIMIT_CODE <>", value, "limitCode");
            return (Criteria) this;
        }

        public Criteria andLimitCodeGreaterThan(String value) {
            addCriterion("LIMIT_CODE >", value, "limitCode");
            return (Criteria) this;
        }

        public Criteria andLimitCodeGreaterThanOrEqualTo(String value) {
            addCriterion("LIMIT_CODE >=", value, "limitCode");
            return (Criteria) this;
        }

        public Criteria andLimitCodeLessThan(String value) {
            addCriterion("LIMIT_CODE <", value, "limitCode");
            return (Criteria) this;
        }

        public Criteria andLimitCodeLessThanOrEqualTo(String value) {
            addCriterion("LIMIT_CODE <=", value, "limitCode");
            return (Criteria) this;
        }

        public Criteria andLimitCodeLike(String value) {
            addCriterion("LIMIT_CODE like", value, "limitCode");
            return (Criteria) this;
        }

        public Criteria andLimitCodeNotLike(String value) {
            addCriterion("LIMIT_CODE not like", value, "limitCode");
            return (Criteria) this;
        }

        public Criteria andLimitCodeIn(List<String> values) {
            addCriterion("LIMIT_CODE in", values, "limitCode");
            return (Criteria) this;
        }

        public Criteria andLimitCodeNotIn(List<String> values) {
            addCriterion("LIMIT_CODE not in", values, "limitCode");
            return (Criteria) this;
        }

        public Criteria andLimitCodeBetween(String value1, String value2) {
            addCriterion("LIMIT_CODE between", value1, value2, "limitCode");
            return (Criteria) this;
        }

        public Criteria andLimitCodeNotBetween(String value1, String value2) {
            addCriterion("LIMIT_CODE not between", value1, value2, "limitCode");
            return (Criteria) this;
        }

        public Criteria andFrequencyCodeIsNull() {
            addCriterion("FREQUENCY_CODE is null");
            return (Criteria) this;
        }

        public Criteria andFrequencyCodeIsNotNull() {
            addCriterion("FREQUENCY_CODE is not null");
            return (Criteria) this;
        }

        public Criteria andFrequencyCodeEqualTo(Short value) {
            addCriterion("FREQUENCY_CODE =", value, "frequencyCode");
            return (Criteria) this;
        }

        public Criteria andFrequencyCodeNotEqualTo(Short value) {
            addCriterion("FREQUENCY_CODE <>", value, "frequencyCode");
            return (Criteria) this;
        }

        public Criteria andFrequencyCodeGreaterThan(Short value) {
            addCriterion("FREQUENCY_CODE >", value, "frequencyCode");
            return (Criteria) this;
        }

        public Criteria andFrequencyCodeGreaterThanOrEqualTo(Short value) {
            addCriterion("FREQUENCY_CODE >=", value, "frequencyCode");
            return (Criteria) this;
        }

        public Criteria andFrequencyCodeLessThan(Short value) {
            addCriterion("FREQUENCY_CODE <", value, "frequencyCode");
            return (Criteria) this;
        }

        public Criteria andFrequencyCodeLessThanOrEqualTo(Short value) {
            addCriterion("FREQUENCY_CODE <=", value, "frequencyCode");
            return (Criteria) this;
        }

        public Criteria andFrequencyCodeIn(List<Short> values) {
            addCriterion("FREQUENCY_CODE in", values, "frequencyCode");
            return (Criteria) this;
        }

        public Criteria andFrequencyCodeNotIn(List<Short> values) {
            addCriterion("FREQUENCY_CODE not in", values, "frequencyCode");
            return (Criteria) this;
        }

        public Criteria andFrequencyCodeBetween(Short value1, Short value2) {
            addCriterion("FREQUENCY_CODE between", value1, value2, "frequencyCode");
            return (Criteria) this;
        }

        public Criteria andFrequencyCodeNotBetween(Short value1, Short value2) {
            addCriterion("FREQUENCY_CODE not between", value1, value2, "frequencyCode");
            return (Criteria) this;
        }

        public Criteria andProviderTypeIsNull() {
            addCriterion("PROVIDER_TYPE is null");
            return (Criteria) this;
        }

        public Criteria andProviderTypeIsNotNull() {
            addCriterion("PROVIDER_TYPE is not null");
            return (Criteria) this;
        }

        public Criteria andProviderTypeEqualTo(String value) {
            addCriterion("PROVIDER_TYPE =", value, "providerType");
            return (Criteria) this;
        }

        public Criteria andProviderTypeNotEqualTo(String value) {
            addCriterion("PROVIDER_TYPE <>", value, "providerType");
            return (Criteria) this;
        }

        public Criteria andProviderTypeGreaterThan(String value) {
            addCriterion("PROVIDER_TYPE >", value, "providerType");
            return (Criteria) this;
        }

        public Criteria andProviderTypeGreaterThanOrEqualTo(String value) {
            addCriterion("PROVIDER_TYPE >=", value, "providerType");
            return (Criteria) this;
        }

        public Criteria andProviderTypeLessThan(String value) {
            addCriterion("PROVIDER_TYPE <", value, "providerType");
            return (Criteria) this;
        }

        public Criteria andProviderTypeLessThanOrEqualTo(String value) {
            addCriterion("PROVIDER_TYPE <=", value, "providerType");
            return (Criteria) this;
        }

        public Criteria andProviderTypeLike(String value) {
            addCriterion("PROVIDER_TYPE like", value, "providerType");
            return (Criteria) this;
        }

        public Criteria andProviderTypeNotLike(String value) {
            addCriterion("PROVIDER_TYPE not like", value, "providerType");
            return (Criteria) this;
        }

        public Criteria andProviderTypeIn(List<String> values) {
            addCriterion("PROVIDER_TYPE in", values, "providerType");
            return (Criteria) this;
        }

        public Criteria andProviderTypeNotIn(List<String> values) {
            addCriterion("PROVIDER_TYPE not in", values, "providerType");
            return (Criteria) this;
        }

        public Criteria andProviderTypeBetween(String value1, String value2) {
            addCriterion("PROVIDER_TYPE between", value1, value2, "providerType");
            return (Criteria) this;
        }

        public Criteria andProviderTypeNotBetween(String value1, String value2) {
            addCriterion("PROVIDER_TYPE not between", value1, value2, "providerType");
            return (Criteria) this;
        }

        public Criteria andInvoiceTypeIsNull() {
            addCriterion("INVOICE_TYPE is null");
            return (Criteria) this;
        }

        public Criteria andInvoiceTypeIsNotNull() {
            addCriterion("INVOICE_TYPE is not null");
            return (Criteria) this;
        }

        public Criteria andInvoiceTypeEqualTo(String value) {
            addCriterion("INVOICE_TYPE =", value, "invoiceType");
            return (Criteria) this;
        }

        public Criteria andInvoiceTypeNotEqualTo(String value) {
            addCriterion("INVOICE_TYPE <>", value, "invoiceType");
            return (Criteria) this;
        }

        public Criteria andInvoiceTypeGreaterThan(String value) {
            addCriterion("INVOICE_TYPE >", value, "invoiceType");
            return (Criteria) this;
        }

        public Criteria andInvoiceTypeGreaterThanOrEqualTo(String value) {
            addCriterion("INVOICE_TYPE >=", value, "invoiceType");
            return (Criteria) this;
        }

        public Criteria andInvoiceTypeLessThan(String value) {
            addCriterion("INVOICE_TYPE <", value, "invoiceType");
            return (Criteria) this;
        }

        public Criteria andInvoiceTypeLessThanOrEqualTo(String value) {
            addCriterion("INVOICE_TYPE <=", value, "invoiceType");
            return (Criteria) this;
        }

        public Criteria andInvoiceTypeLike(String value) {
            addCriterion("INVOICE_TYPE like", value, "invoiceType");
            return (Criteria) this;
        }

        public Criteria andInvoiceTypeNotLike(String value) {
            addCriterion("INVOICE_TYPE not like", value, "invoiceType");
            return (Criteria) this;
        }

        public Criteria andInvoiceTypeIn(List<String> values) {
            addCriterion("INVOICE_TYPE in", values, "invoiceType");
            return (Criteria) this;
        }

        public Criteria andInvoiceTypeNotIn(List<String> values) {
            addCriterion("INVOICE_TYPE not in", values, "invoiceType");
            return (Criteria) this;
        }

        public Criteria andInvoiceTypeBetween(String value1, String value2) {
            addCriterion("INVOICE_TYPE between", value1, value2, "invoiceType");
            return (Criteria) this;
        }

        public Criteria andInvoiceTypeNotBetween(String value1, String value2) {
            addCriterion("INVOICE_TYPE not between", value1, value2, "invoiceType");
            return (Criteria) this;
        }

        public Criteria andCountryIsNull() {
            addCriterion("COUNTRY is null");
            return (Criteria) this;
        }

        public Criteria andCountryIsNotNull() {
            addCriterion("COUNTRY is not null");
            return (Criteria) this;
        }

        public Criteria andCountryEqualTo(String value) {
            addCriterion("COUNTRY =", value, "country");
            return (Criteria) this;
        }

        public Criteria andCountryNotEqualTo(String value) {
            addCriterion("COUNTRY <>", value, "country");
            return (Criteria) this;
        }

        public Criteria andCountryGreaterThan(String value) {
            addCriterion("COUNTRY >", value, "country");
            return (Criteria) this;
        }

        public Criteria andCountryGreaterThanOrEqualTo(String value) {
            addCriterion("COUNTRY >=", value, "country");
            return (Criteria) this;
        }

        public Criteria andCountryLessThan(String value) {
            addCriterion("COUNTRY <", value, "country");
            return (Criteria) this;
        }

        public Criteria andCountryLessThanOrEqualTo(String value) {
            addCriterion("COUNTRY <=", value, "country");
            return (Criteria) this;
        }

        public Criteria andCountryLike(String value) {
            addCriterion("COUNTRY like", value, "country");
            return (Criteria) this;
        }

        public Criteria andCountryNotLike(String value) {
            addCriterion("COUNTRY not like", value, "country");
            return (Criteria) this;
        }

        public Criteria andCountryIn(List<String> values) {
            addCriterion("COUNTRY in", values, "country");
            return (Criteria) this;
        }

        public Criteria andCountryNotIn(List<String> values) {
            addCriterion("COUNTRY not in", values, "country");
            return (Criteria) this;
        }

        public Criteria andCountryBetween(String value1, String value2) {
            addCriterion("COUNTRY between", value1, value2, "country");
            return (Criteria) this;
        }

        public Criteria andCountryNotBetween(String value1, String value2) {
            addCriterion("COUNTRY not between", value1, value2, "country");
            return (Criteria) this;
        }

        public Criteria andStartDateIsNull() {
            addCriterion("START_DATE is null");
            return (Criteria) this;
        }

        public Criteria andStartDateIsNotNull() {
            addCriterion("START_DATE is not null");
            return (Criteria) this;
        }

        public Criteria andStartDateEqualTo(Date value) {
            addCriterion("START_DATE =", value, "startDate");
            return (Criteria) this;
        }

        public Criteria andStartDateNotEqualTo(Date value) {
            addCriterion("START_DATE <>", value, "startDate");
            return (Criteria) this;
        }

        public Criteria andStartDateGreaterThan(Date value) {
            addCriterion("START_DATE >", value, "startDate");
            return (Criteria) this;
        }

        public Criteria andStartDateGreaterThanOrEqualTo(Date value) {
            addCriterion("START_DATE >=", value, "startDate");
            return (Criteria) this;
        }

        public Criteria andStartDateLessThan(Date value) {
            addCriterion("START_DATE <", value, "startDate");
            return (Criteria) this;
        }

        public Criteria andStartDateLessThanOrEqualTo(Date value) {
            addCriterion("START_DATE <=", value, "startDate");
            return (Criteria) this;
        }

        public Criteria andStartDateIn(List<Date> values) {
            addCriterion("START_DATE in", values, "startDate");
            return (Criteria) this;
        }

        public Criteria andStartDateNotIn(List<Date> values) {
            addCriterion("START_DATE not in", values, "startDate");
            return (Criteria) this;
        }

        public Criteria andStartDateBetween(Date value1, Date value2) {
            addCriterion("START_DATE between", value1, value2, "startDate");
            return (Criteria) this;
        }

        public Criteria andStartDateNotBetween(Date value1, Date value2) {
            addCriterion("START_DATE not between", value1, value2, "startDate");
            return (Criteria) this;
        }

        public Criteria andSnoIsNull() {
            addCriterion("SNO is null");
            return (Criteria) this;
        }

        public Criteria andSnoIsNotNull() {
            addCriterion("SNO is not null");
            return (Criteria) this;
        }

        public Criteria andSnoEqualTo(Short value) {
            addCriterion("SNO =", value, "sno");
            return (Criteria) this;
        }

        public Criteria andSnoNotEqualTo(Short value) {
            addCriterion("SNO <>", value, "sno");
            return (Criteria) this;
        }

        public Criteria andSnoGreaterThan(Short value) {
            addCriterion("SNO >", value, "sno");
            return (Criteria) this;
        }

        public Criteria andSnoGreaterThanOrEqualTo(Short value) {
            addCriterion("SNO >=", value, "sno");
            return (Criteria) this;
        }

        public Criteria andSnoLessThan(Short value) {
            addCriterion("SNO <", value, "sno");
            return (Criteria) this;
        }

        public Criteria andSnoLessThanOrEqualTo(Short value) {
            addCriterion("SNO <=", value, "sno");
            return (Criteria) this;
        }

        public Criteria andSnoIn(List<Short> values) {
            addCriterion("SNO in", values, "sno");
            return (Criteria) this;
        }

        public Criteria andSnoNotIn(List<Short> values) {
            addCriterion("SNO not in", values, "sno");
            return (Criteria) this;
        }

        public Criteria andSnoBetween(Short value1, Short value2) {
            addCriterion("SNO between", value1, value2, "sno");
            return (Criteria) this;
        }

        public Criteria andSnoNotBetween(Short value1, Short value2) {
            addCriterion("SNO not between", value1, value2, "sno");
            return (Criteria) this;
        }

        public Criteria andEndDateIsNull() {
            addCriterion("END_DATE is null");
            return (Criteria) this;
        }

        public Criteria andEndDateIsNotNull() {
            addCriterion("END_DATE is not null");
            return (Criteria) this;
        }

        public Criteria andEndDateEqualTo(Date value) {
            addCriterion("END_DATE =", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateNotEqualTo(Date value) {
            addCriterion("END_DATE <>", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateGreaterThan(Date value) {
            addCriterion("END_DATE >", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateGreaterThanOrEqualTo(Date value) {
            addCriterion("END_DATE >=", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateLessThan(Date value) {
            addCriterion("END_DATE <", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateLessThanOrEqualTo(Date value) {
            addCriterion("END_DATE <=", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateIn(List<Date> values) {
            addCriterion("END_DATE in", values, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateNotIn(List<Date> values) {
            addCriterion("END_DATE not in", values, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateBetween(Date value1, Date value2) {
            addCriterion("END_DATE between", value1, value2, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateNotBetween(Date value1, Date value2) {
            addCriterion("END_DATE not between", value1, value2, "endDate");
            return (Criteria) this;
        }

        public Criteria andLasteditDateIsNull() {
            addCriterion("LASTEDIT_DATE is null");
            return (Criteria) this;
        }

        public Criteria andLasteditDateIsNotNull() {
            addCriterion("LASTEDIT_DATE is not null");
            return (Criteria) this;
        }

        public Criteria andLasteditDateEqualTo(Date value) {
            addCriterion("LASTEDIT_DATE =", value, "lasteditDate");
            return (Criteria) this;
        }

        public Criteria andLasteditDateNotEqualTo(Date value) {
            addCriterion("LASTEDIT_DATE <>", value, "lasteditDate");
            return (Criteria) this;
        }

        public Criteria andLasteditDateGreaterThan(Date value) {
            addCriterion("LASTEDIT_DATE >", value, "lasteditDate");
            return (Criteria) this;
        }

        public Criteria andLasteditDateGreaterThanOrEqualTo(Date value) {
            addCriterion("LASTEDIT_DATE >=", value, "lasteditDate");
            return (Criteria) this;
        }

        public Criteria andLasteditDateLessThan(Date value) {
            addCriterion("LASTEDIT_DATE <", value, "lasteditDate");
            return (Criteria) this;
        }

        public Criteria andLasteditDateLessThanOrEqualTo(Date value) {
            addCriterion("LASTEDIT_DATE <=", value, "lasteditDate");
            return (Criteria) this;
        }

        public Criteria andLasteditDateIn(List<Date> values) {
            addCriterion("LASTEDIT_DATE in", values, "lasteditDate");
            return (Criteria) this;
        }

        public Criteria andLasteditDateNotIn(List<Date> values) {
            addCriterion("LASTEDIT_DATE not in", values, "lasteditDate");
            return (Criteria) this;
        }

        public Criteria andLasteditDateBetween(Date value1, Date value2) {
            addCriterion("LASTEDIT_DATE between", value1, value2, "lasteditDate");
            return (Criteria) this;
        }

        public Criteria andLasteditDateNotBetween(Date value1, Date value2) {
            addCriterion("LASTEDIT_DATE not between", value1, value2, "lasteditDate");
            return (Criteria) this;
        }

        public Criteria andUserCodeIsNull() {
            addCriterion("USER_CODE is null");
            return (Criteria) this;
        }

        public Criteria andUserCodeIsNotNull() {
            addCriterion("USER_CODE is not null");
            return (Criteria) this;
        }

        public Criteria andUserCodeEqualTo(String value) {
            addCriterion("USER_CODE =", value, "userCode");
            return (Criteria) this;
        }

        public Criteria andUserCodeNotEqualTo(String value) {
            addCriterion("USER_CODE <>", value, "userCode");
            return (Criteria) this;
        }

        public Criteria andUserCodeGreaterThan(String value) {
            addCriterion("USER_CODE >", value, "userCode");
            return (Criteria) this;
        }

        public Criteria andUserCodeGreaterThanOrEqualTo(String value) {
            addCriterion("USER_CODE >=", value, "userCode");
            return (Criteria) this;
        }

        public Criteria andUserCodeLessThan(String value) {
            addCriterion("USER_CODE <", value, "userCode");
            return (Criteria) this;
        }

        public Criteria andUserCodeLessThanOrEqualTo(String value) {
            addCriterion("USER_CODE <=", value, "userCode");
            return (Criteria) this;
        }

        public Criteria andUserCodeLike(String value) {
            addCriterion("USER_CODE like", value, "userCode");
            return (Criteria) this;
        }

        public Criteria andUserCodeNotLike(String value) {
            addCriterion("USER_CODE not like", value, "userCode");
            return (Criteria) this;
        }

        public Criteria andUserCodeIn(List<String> values) {
            addCriterion("USER_CODE in", values, "userCode");
            return (Criteria) this;
        }

        public Criteria andUserCodeNotIn(List<String> values) {
            addCriterion("USER_CODE not in", values, "userCode");
            return (Criteria) this;
        }

        public Criteria andUserCodeBetween(String value1, String value2) {
            addCriterion("USER_CODE between", value1, value2, "userCode");
            return (Criteria) this;
        }

        public Criteria andUserCodeNotBetween(String value1, String value2) {
            addCriterion("USER_CODE not between", value1, value2, "userCode");
            return (Criteria) this;
        }

        public Criteria andActiveFlagIsNull() {
            addCriterion("ACTIVE_FLAG is null");
            return (Criteria) this;
        }

        public Criteria andActiveFlagIsNotNull() {
            addCriterion("ACTIVE_FLAG is not null");
            return (Criteria) this;
        }

        public Criteria andActiveFlagEqualTo(String value) {
            addCriterion("ACTIVE_FLAG =", value, "activeFlag");
            return (Criteria) this;
        }

        public Criteria andActiveFlagNotEqualTo(String value) {
            addCriterion("ACTIVE_FLAG <>", value, "activeFlag");
            return (Criteria) this;
        }

        public Criteria andActiveFlagGreaterThan(String value) {
            addCriterion("ACTIVE_FLAG >", value, "activeFlag");
            return (Criteria) this;
        }

        public Criteria andActiveFlagGreaterThanOrEqualTo(String value) {
            addCriterion("ACTIVE_FLAG >=", value, "activeFlag");
            return (Criteria) this;
        }

        public Criteria andActiveFlagLessThan(String value) {
            addCriterion("ACTIVE_FLAG <", value, "activeFlag");
            return (Criteria) this;
        }

        public Criteria andActiveFlagLessThanOrEqualTo(String value) {
            addCriterion("ACTIVE_FLAG <=", value, "activeFlag");
            return (Criteria) this;
        }

        public Criteria andActiveFlagLike(String value) {
            addCriterion("ACTIVE_FLAG like", value, "activeFlag");
            return (Criteria) this;
        }

        public Criteria andActiveFlagNotLike(String value) {
            addCriterion("ACTIVE_FLAG not like", value, "activeFlag");
            return (Criteria) this;
        }

        public Criteria andActiveFlagIn(List<String> values) {
            addCriterion("ACTIVE_FLAG in", values, "activeFlag");
            return (Criteria) this;
        }

        public Criteria andActiveFlagNotIn(List<String> values) {
            addCriterion("ACTIVE_FLAG not in", values, "activeFlag");
            return (Criteria) this;
        }

        public Criteria andActiveFlagBetween(String value1, String value2) {
            addCriterion("ACTIVE_FLAG between", value1, value2, "activeFlag");
            return (Criteria) this;
        }

        public Criteria andActiveFlagNotBetween(String value1, String value2) {
            addCriterion("ACTIVE_FLAG not between", value1, value2, "activeFlag");
            return (Criteria) this;
        }

        public Criteria andMinValueIsNull() {
            addCriterion("MIN_VALUE is null");
            return (Criteria) this;
        }

        public Criteria andMinValueIsNotNull() {
            addCriterion("MIN_VALUE is not null");
            return (Criteria) this;
        }

        public Criteria andMinValueEqualTo(BigDecimal value) {
            addCriterion("MIN_VALUE =", value, "minValue");
            return (Criteria) this;
        }

        public Criteria andMinValueNotEqualTo(BigDecimal value) {
            addCriterion("MIN_VALUE <>", value, "minValue");
            return (Criteria) this;
        }

        public Criteria andMinValueGreaterThan(BigDecimal value) {
            addCriterion("MIN_VALUE >", value, "minValue");
            return (Criteria) this;
        }

        public Criteria andMinValueGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("MIN_VALUE >=", value, "minValue");
            return (Criteria) this;
        }

        public Criteria andMinValueLessThan(BigDecimal value) {
            addCriterion("MIN_VALUE <", value, "minValue");
            return (Criteria) this;
        }

        public Criteria andMinValueLessThanOrEqualTo(BigDecimal value) {
            addCriterion("MIN_VALUE <=", value, "minValue");
            return (Criteria) this;
        }

        public Criteria andMinValueIn(List<BigDecimal> values) {
            addCriterion("MIN_VALUE in", values, "minValue");
            return (Criteria) this;
        }

        public Criteria andMinValueNotIn(List<BigDecimal> values) {
            addCriterion("MIN_VALUE not in", values, "minValue");
            return (Criteria) this;
        }

        public Criteria andMinValueBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("MIN_VALUE between", value1, value2, "minValue");
            return (Criteria) this;
        }

        public Criteria andMinValueNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("MIN_VALUE not between", value1, value2, "minValue");
            return (Criteria) this;
        }

        public Criteria andMaxValueIsNull() {
            addCriterion("MAX_VALUE is null");
            return (Criteria) this;
        }

        public Criteria andMaxValueIsNotNull() {
            addCriterion("MAX_VALUE is not null");
            return (Criteria) this;
        }

        public Criteria andMaxValueEqualTo(BigDecimal value) {
            addCriterion("MAX_VALUE =", value, "maxValue");
            return (Criteria) this;
        }

        public Criteria andMaxValueNotEqualTo(BigDecimal value) {
            addCriterion("MAX_VALUE <>", value, "maxValue");
            return (Criteria) this;
        }

        public Criteria andMaxValueGreaterThan(BigDecimal value) {
            addCriterion("MAX_VALUE >", value, "maxValue");
            return (Criteria) this;
        }

        public Criteria andMaxValueGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("MAX_VALUE >=", value, "maxValue");
            return (Criteria) this;
        }

        public Criteria andMaxValueLessThan(BigDecimal value) {
            addCriterion("MAX_VALUE <", value, "maxValue");
            return (Criteria) this;
        }

        public Criteria andMaxValueLessThanOrEqualTo(BigDecimal value) {
            addCriterion("MAX_VALUE <=", value, "maxValue");
            return (Criteria) this;
        }

        public Criteria andMaxValueIn(List<BigDecimal> values) {
            addCriterion("MAX_VALUE in", values, "maxValue");
            return (Criteria) this;
        }

        public Criteria andMaxValueNotIn(List<BigDecimal> values) {
            addCriterion("MAX_VALUE not in", values, "maxValue");
            return (Criteria) this;
        }

        public Criteria andMaxValueBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("MAX_VALUE between", value1, value2, "maxValue");
            return (Criteria) this;
        }

        public Criteria andMaxValueNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("MAX_VALUE not between", value1, value2, "maxValue");
            return (Criteria) this;
        }

        public Criteria andDependentMaxValueIsNull() {
            addCriterion("DEPENDENT_MAX_VALUE is null");
            return (Criteria) this;
        }

        public Criteria andDependentMaxValueIsNotNull() {
            addCriterion("DEPENDENT_MAX_VALUE is not null");
            return (Criteria) this;
        }

        public Criteria andDependentMaxValueEqualTo(BigDecimal value) {
            addCriterion("DEPENDENT_MAX_VALUE =", value, "dependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andDependentMaxValueNotEqualTo(BigDecimal value) {
            addCriterion("DEPENDENT_MAX_VALUE <>", value, "dependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andDependentMaxValueGreaterThan(BigDecimal value) {
            addCriterion("DEPENDENT_MAX_VALUE >", value, "dependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andDependentMaxValueGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("DEPENDENT_MAX_VALUE >=", value, "dependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andDependentMaxValueLessThan(BigDecimal value) {
            addCriterion("DEPENDENT_MAX_VALUE <", value, "dependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andDependentMaxValueLessThanOrEqualTo(BigDecimal value) {
            addCriterion("DEPENDENT_MAX_VALUE <=", value, "dependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andDependentMaxValueIn(List<BigDecimal> values) {
            addCriterion("DEPENDENT_MAX_VALUE in", values, "dependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andDependentMaxValueNotIn(List<BigDecimal> values) {
            addCriterion("DEPENDENT_MAX_VALUE not in", values, "dependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andDependentMaxValueBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DEPENDENT_MAX_VALUE between", value1, value2, "dependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andDependentMaxValueNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("DEPENDENT_MAX_VALUE not between", value1, value2, "dependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andFamilyMaxValueIsNull() {
            addCriterion("FAMILY_MAX_VALUE is null");
            return (Criteria) this;
        }

        public Criteria andFamilyMaxValueIsNotNull() {
            addCriterion("FAMILY_MAX_VALUE is not null");
            return (Criteria) this;
        }

        public Criteria andFamilyMaxValueEqualTo(BigDecimal value) {
            addCriterion("FAMILY_MAX_VALUE =", value, "familyMaxValue");
            return (Criteria) this;
        }

        public Criteria andFamilyMaxValueNotEqualTo(BigDecimal value) {
            addCriterion("FAMILY_MAX_VALUE <>", value, "familyMaxValue");
            return (Criteria) this;
        }

        public Criteria andFamilyMaxValueGreaterThan(BigDecimal value) {
            addCriterion("FAMILY_MAX_VALUE >", value, "familyMaxValue");
            return (Criteria) this;
        }

        public Criteria andFamilyMaxValueGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("FAMILY_MAX_VALUE >=", value, "familyMaxValue");
            return (Criteria) this;
        }

        public Criteria andFamilyMaxValueLessThan(BigDecimal value) {
            addCriterion("FAMILY_MAX_VALUE <", value, "familyMaxValue");
            return (Criteria) this;
        }

        public Criteria andFamilyMaxValueLessThanOrEqualTo(BigDecimal value) {
            addCriterion("FAMILY_MAX_VALUE <=", value, "familyMaxValue");
            return (Criteria) this;
        }

        public Criteria andFamilyMaxValueIn(List<BigDecimal> values) {
            addCriterion("FAMILY_MAX_VALUE in", values, "familyMaxValue");
            return (Criteria) this;
        }

        public Criteria andFamilyMaxValueNotIn(List<BigDecimal> values) {
            addCriterion("FAMILY_MAX_VALUE not in", values, "familyMaxValue");
            return (Criteria) this;
        }

        public Criteria andFamilyMaxValueBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("FAMILY_MAX_VALUE between", value1, value2, "familyMaxValue");
            return (Criteria) this;
        }

        public Criteria andFamilyMaxValueNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("FAMILY_MAX_VALUE not between", value1, value2, "familyMaxValue");
            return (Criteria) this;
        }

        public Criteria andConditionTypeIsNull() {
            addCriterion("CONDITION_TYPE is null");
            return (Criteria) this;
        }

        public Criteria andConditionTypeIsNotNull() {
            addCriterion("CONDITION_TYPE is not null");
            return (Criteria) this;
        }

        public Criteria andConditionTypeEqualTo(Short value) {
            addCriterion("CONDITION_TYPE =", value, "conditionType");
            return (Criteria) this;
        }

        public Criteria andConditionTypeNotEqualTo(Short value) {
            addCriterion("CONDITION_TYPE <>", value, "conditionType");
            return (Criteria) this;
        }

        public Criteria andConditionTypeGreaterThan(Short value) {
            addCriterion("CONDITION_TYPE >", value, "conditionType");
            return (Criteria) this;
        }

        public Criteria andConditionTypeGreaterThanOrEqualTo(Short value) {
            addCriterion("CONDITION_TYPE >=", value, "conditionType");
            return (Criteria) this;
        }

        public Criteria andConditionTypeLessThan(Short value) {
            addCriterion("CONDITION_TYPE <", value, "conditionType");
            return (Criteria) this;
        }

        public Criteria andConditionTypeLessThanOrEqualTo(Short value) {
            addCriterion("CONDITION_TYPE <=", value, "conditionType");
            return (Criteria) this;
        }

        public Criteria andConditionTypeIn(List<Short> values) {
            addCriterion("CONDITION_TYPE in", values, "conditionType");
            return (Criteria) this;
        }

        public Criteria andConditionTypeNotIn(List<Short> values) {
            addCriterion("CONDITION_TYPE not in", values, "conditionType");
            return (Criteria) this;
        }

        public Criteria andConditionTypeBetween(Short value1, Short value2) {
            addCriterion("CONDITION_TYPE between", value1, value2, "conditionType");
            return (Criteria) this;
        }

        public Criteria andConditionTypeNotBetween(Short value1, Short value2) {
            addCriterion("CONDITION_TYPE not between", value1, value2, "conditionType");
            return (Criteria) this;
        }

        public Criteria andAttachCodeIsNull() {
            addCriterion("ATTACH_CODE is null");
            return (Criteria) this;
        }

        public Criteria andAttachCodeIsNotNull() {
            addCriterion("ATTACH_CODE is not null");
            return (Criteria) this;
        }

        public Criteria andAttachCodeEqualTo(String value) {
            addCriterion("ATTACH_CODE =", value, "attachCode");
            return (Criteria) this;
        }

        public Criteria andAttachCodeNotEqualTo(String value) {
            addCriterion("ATTACH_CODE <>", value, "attachCode");
            return (Criteria) this;
        }

        public Criteria andAttachCodeGreaterThan(String value) {
            addCriterion("ATTACH_CODE >", value, "attachCode");
            return (Criteria) this;
        }

        public Criteria andAttachCodeGreaterThanOrEqualTo(String value) {
            addCriterion("ATTACH_CODE >=", value, "attachCode");
            return (Criteria) this;
        }

        public Criteria andAttachCodeLessThan(String value) {
            addCriterion("ATTACH_CODE <", value, "attachCode");
            return (Criteria) this;
        }

        public Criteria andAttachCodeLessThanOrEqualTo(String value) {
            addCriterion("ATTACH_CODE <=", value, "attachCode");
            return (Criteria) this;
        }

        public Criteria andAttachCodeLike(String value) {
            addCriterion("ATTACH_CODE like", value, "attachCode");
            return (Criteria) this;
        }

        public Criteria andAttachCodeNotLike(String value) {
            addCriterion("ATTACH_CODE not like", value, "attachCode");
            return (Criteria) this;
        }

        public Criteria andAttachCodeIn(List<String> values) {
            addCriterion("ATTACH_CODE in", values, "attachCode");
            return (Criteria) this;
        }

        public Criteria andAttachCodeNotIn(List<String> values) {
            addCriterion("ATTACH_CODE not in", values, "attachCode");
            return (Criteria) this;
        }

        public Criteria andAttachCodeBetween(String value1, String value2) {
            addCriterion("ATTACH_CODE between", value1, value2, "attachCode");
            return (Criteria) this;
        }

        public Criteria andAttachCodeNotBetween(String value1, String value2) {
            addCriterion("ATTACH_CODE not between", value1, value2, "attachCode");
            return (Criteria) this;
        }

        public Criteria andPrintValueIsNull() {
            addCriterion("PRINT_VALUE is null");
            return (Criteria) this;
        }

        public Criteria andPrintValueIsNotNull() {
            addCriterion("PRINT_VALUE is not null");
            return (Criteria) this;
        }

        public Criteria andPrintValueEqualTo(String value) {
            addCriterion("PRINT_VALUE =", value, "printValue");
            return (Criteria) this;
        }

        public Criteria andPrintValueNotEqualTo(String value) {
            addCriterion("PRINT_VALUE <>", value, "printValue");
            return (Criteria) this;
        }

        public Criteria andPrintValueGreaterThan(String value) {
            addCriterion("PRINT_VALUE >", value, "printValue");
            return (Criteria) this;
        }

        public Criteria andPrintValueGreaterThanOrEqualTo(String value) {
            addCriterion("PRINT_VALUE >=", value, "printValue");
            return (Criteria) this;
        }

        public Criteria andPrintValueLessThan(String value) {
            addCriterion("PRINT_VALUE <", value, "printValue");
            return (Criteria) this;
        }

        public Criteria andPrintValueLessThanOrEqualTo(String value) {
            addCriterion("PRINT_VALUE <=", value, "printValue");
            return (Criteria) this;
        }

        public Criteria andPrintValueLike(String value) {
            addCriterion("PRINT_VALUE like", value, "printValue");
            return (Criteria) this;
        }

        public Criteria andPrintValueNotLike(String value) {
            addCriterion("PRINT_VALUE not like", value, "printValue");
            return (Criteria) this;
        }

        public Criteria andPrintValueIn(List<String> values) {
            addCriterion("PRINT_VALUE in", values, "printValue");
            return (Criteria) this;
        }

        public Criteria andPrintValueNotIn(List<String> values) {
            addCriterion("PRINT_VALUE not in", values, "printValue");
            return (Criteria) this;
        }

        public Criteria andPrintValueBetween(String value1, String value2) {
            addCriterion("PRINT_VALUE between", value1, value2, "printValue");
            return (Criteria) this;
        }

        public Criteria andPrintValueNotBetween(String value1, String value2) {
            addCriterion("PRINT_VALUE not between", value1, value2, "printValue");
            return (Criteria) this;
        }

        public Criteria andRejectCodeIsNull() {
            addCriterion("REJECT_CODE is null");
            return (Criteria) this;
        }

        public Criteria andRejectCodeIsNotNull() {
            addCriterion("REJECT_CODE is not null");
            return (Criteria) this;
        }

        public Criteria andRejectCodeEqualTo(Integer value) {
            addCriterion("REJECT_CODE =", value, "rejectCode");
            return (Criteria) this;
        }

        public Criteria andRejectCodeNotEqualTo(Integer value) {
            addCriterion("REJECT_CODE <>", value, "rejectCode");
            return (Criteria) this;
        }

        public Criteria andRejectCodeGreaterThan(Integer value) {
            addCriterion("REJECT_CODE >", value, "rejectCode");
            return (Criteria) this;
        }

        public Criteria andRejectCodeGreaterThanOrEqualTo(Integer value) {
            addCriterion("REJECT_CODE >=", value, "rejectCode");
            return (Criteria) this;
        }

        public Criteria andRejectCodeLessThan(Integer value) {
            addCriterion("REJECT_CODE <", value, "rejectCode");
            return (Criteria) this;
        }

        public Criteria andRejectCodeLessThanOrEqualTo(Integer value) {
            addCriterion("REJECT_CODE <=", value, "rejectCode");
            return (Criteria) this;
        }

        public Criteria andRejectCodeIn(List<Integer> values) {
            addCriterion("REJECT_CODE in", values, "rejectCode");
            return (Criteria) this;
        }

        public Criteria andRejectCodeNotIn(List<Integer> values) {
            addCriterion("REJECT_CODE not in", values, "rejectCode");
            return (Criteria) this;
        }

        public Criteria andRejectCodeBetween(Integer value1, Integer value2) {
            addCriterion("REJECT_CODE between", value1, value2, "rejectCode");
            return (Criteria) this;
        }

        public Criteria andRejectCodeNotBetween(Integer value1, Integer value2) {
            addCriterion("REJECT_CODE not between", value1, value2, "rejectCode");
            return (Criteria) this;
        }

        public Criteria andIfcondTypeIsNull() {
            addCriterion("IFCOND_TYPE is null");
            return (Criteria) this;
        }

        public Criteria andIfcondTypeIsNotNull() {
            addCriterion("IFCOND_TYPE is not null");
            return (Criteria) this;
        }

        public Criteria andIfcondTypeEqualTo(String value) {
            addCriterion("IFCOND_TYPE =", value, "ifcondType");
            return (Criteria) this;
        }

        public Criteria andIfcondTypeNotEqualTo(String value) {
            addCriterion("IFCOND_TYPE <>", value, "ifcondType");
            return (Criteria) this;
        }

        public Criteria andIfcondTypeGreaterThan(String value) {
            addCriterion("IFCOND_TYPE >", value, "ifcondType");
            return (Criteria) this;
        }

        public Criteria andIfcondTypeGreaterThanOrEqualTo(String value) {
            addCriterion("IFCOND_TYPE >=", value, "ifcondType");
            return (Criteria) this;
        }

        public Criteria andIfcondTypeLessThan(String value) {
            addCriterion("IFCOND_TYPE <", value, "ifcondType");
            return (Criteria) this;
        }

        public Criteria andIfcondTypeLessThanOrEqualTo(String value) {
            addCriterion("IFCOND_TYPE <=", value, "ifcondType");
            return (Criteria) this;
        }

        public Criteria andIfcondTypeLike(String value) {
            addCriterion("IFCOND_TYPE like", value, "ifcondType");
            return (Criteria) this;
        }

        public Criteria andIfcondTypeNotLike(String value) {
            addCriterion("IFCOND_TYPE not like", value, "ifcondType");
            return (Criteria) this;
        }

        public Criteria andIfcondTypeIn(List<String> values) {
            addCriterion("IFCOND_TYPE in", values, "ifcondType");
            return (Criteria) this;
        }

        public Criteria andIfcondTypeNotIn(List<String> values) {
            addCriterion("IFCOND_TYPE not in", values, "ifcondType");
            return (Criteria) this;
        }

        public Criteria andIfcondTypeBetween(String value1, String value2) {
            addCriterion("IFCOND_TYPE between", value1, value2, "ifcondType");
            return (Criteria) this;
        }

        public Criteria andIfcondTypeNotBetween(String value1, String value2) {
            addCriterion("IFCOND_TYPE not between", value1, value2, "ifcondType");
            return (Criteria) this;
        }

        public Criteria andIfcondGevalIsNull() {
            addCriterion("IFCOND_GEVAL is null");
            return (Criteria) this;
        }

        public Criteria andIfcondGevalIsNotNull() {
            addCriterion("IFCOND_GEVAL is not null");
            return (Criteria) this;
        }

        public Criteria andIfcondGevalEqualTo(BigDecimal value) {
            addCriterion("IFCOND_GEVAL =", value, "ifcondGeval");
            return (Criteria) this;
        }

        public Criteria andIfcondGevalNotEqualTo(BigDecimal value) {
            addCriterion("IFCOND_GEVAL <>", value, "ifcondGeval");
            return (Criteria) this;
        }

        public Criteria andIfcondGevalGreaterThan(BigDecimal value) {
            addCriterion("IFCOND_GEVAL >", value, "ifcondGeval");
            return (Criteria) this;
        }

        public Criteria andIfcondGevalGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("IFCOND_GEVAL >=", value, "ifcondGeval");
            return (Criteria) this;
        }

        public Criteria andIfcondGevalLessThan(BigDecimal value) {
            addCriterion("IFCOND_GEVAL <", value, "ifcondGeval");
            return (Criteria) this;
        }

        public Criteria andIfcondGevalLessThanOrEqualTo(BigDecimal value) {
            addCriterion("IFCOND_GEVAL <=", value, "ifcondGeval");
            return (Criteria) this;
        }

        public Criteria andIfcondGevalIn(List<BigDecimal> values) {
            addCriterion("IFCOND_GEVAL in", values, "ifcondGeval");
            return (Criteria) this;
        }

        public Criteria andIfcondGevalNotIn(List<BigDecimal> values) {
            addCriterion("IFCOND_GEVAL not in", values, "ifcondGeval");
            return (Criteria) this;
        }

        public Criteria andIfcondGevalBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("IFCOND_GEVAL between", value1, value2, "ifcondGeval");
            return (Criteria) this;
        }

        public Criteria andIfcondGevalNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("IFCOND_GEVAL not between", value1, value2, "ifcondGeval");
            return (Criteria) this;
        }

        public Criteria andIfcondLevalIsNull() {
            addCriterion("IFCOND_LEVAL is null");
            return (Criteria) this;
        }

        public Criteria andIfcondLevalIsNotNull() {
            addCriterion("IFCOND_LEVAL is not null");
            return (Criteria) this;
        }

        public Criteria andIfcondLevalEqualTo(BigDecimal value) {
            addCriterion("IFCOND_LEVAL =", value, "ifcondLeval");
            return (Criteria) this;
        }

        public Criteria andIfcondLevalNotEqualTo(BigDecimal value) {
            addCriterion("IFCOND_LEVAL <>", value, "ifcondLeval");
            return (Criteria) this;
        }

        public Criteria andIfcondLevalGreaterThan(BigDecimal value) {
            addCriterion("IFCOND_LEVAL >", value, "ifcondLeval");
            return (Criteria) this;
        }

        public Criteria andIfcondLevalGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("IFCOND_LEVAL >=", value, "ifcondLeval");
            return (Criteria) this;
        }

        public Criteria andIfcondLevalLessThan(BigDecimal value) {
            addCriterion("IFCOND_LEVAL <", value, "ifcondLeval");
            return (Criteria) this;
        }

        public Criteria andIfcondLevalLessThanOrEqualTo(BigDecimal value) {
            addCriterion("IFCOND_LEVAL <=", value, "ifcondLeval");
            return (Criteria) this;
        }

        public Criteria andIfcondLevalIn(List<BigDecimal> values) {
            addCriterion("IFCOND_LEVAL in", values, "ifcondLeval");
            return (Criteria) this;
        }

        public Criteria andIfcondLevalNotIn(List<BigDecimal> values) {
            addCriterion("IFCOND_LEVAL not in", values, "ifcondLeval");
            return (Criteria) this;
        }

        public Criteria andIfcondLevalBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("IFCOND_LEVAL between", value1, value2, "ifcondLeval");
            return (Criteria) this;
        }

        public Criteria andIfcondLevalNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("IFCOND_LEVAL not between", value1, value2, "ifcondLeval");
            return (Criteria) this;
        }

        public Criteria andIfcondDeductibleIsNull() {
            addCriterion("IFCOND_DEDUCTIBLE is null");
            return (Criteria) this;
        }

        public Criteria andIfcondDeductibleIsNotNull() {
            addCriterion("IFCOND_DEDUCTIBLE is not null");
            return (Criteria) this;
        }

        public Criteria andIfcondDeductibleEqualTo(BigDecimal value) {
            addCriterion("IFCOND_DEDUCTIBLE =", value, "ifcondDeductible");
            return (Criteria) this;
        }

        public Criteria andIfcondDeductibleNotEqualTo(BigDecimal value) {
            addCriterion("IFCOND_DEDUCTIBLE <>", value, "ifcondDeductible");
            return (Criteria) this;
        }

        public Criteria andIfcondDeductibleGreaterThan(BigDecimal value) {
            addCriterion("IFCOND_DEDUCTIBLE >", value, "ifcondDeductible");
            return (Criteria) this;
        }

        public Criteria andIfcondDeductibleGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("IFCOND_DEDUCTIBLE >=", value, "ifcondDeductible");
            return (Criteria) this;
        }

        public Criteria andIfcondDeductibleLessThan(BigDecimal value) {
            addCriterion("IFCOND_DEDUCTIBLE <", value, "ifcondDeductible");
            return (Criteria) this;
        }

        public Criteria andIfcondDeductibleLessThanOrEqualTo(BigDecimal value) {
            addCriterion("IFCOND_DEDUCTIBLE <=", value, "ifcondDeductible");
            return (Criteria) this;
        }

        public Criteria andIfcondDeductibleIn(List<BigDecimal> values) {
            addCriterion("IFCOND_DEDUCTIBLE in", values, "ifcondDeductible");
            return (Criteria) this;
        }

        public Criteria andIfcondDeductibleNotIn(List<BigDecimal> values) {
            addCriterion("IFCOND_DEDUCTIBLE not in", values, "ifcondDeductible");
            return (Criteria) this;
        }

        public Criteria andIfcondDeductibleBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("IFCOND_DEDUCTIBLE between", value1, value2, "ifcondDeductible");
            return (Criteria) this;
        }

        public Criteria andIfcondDeductibleNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("IFCOND_DEDUCTIBLE not between", value1, value2, "ifcondDeductible");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrmincapIsNull() {
            addCriterion("IFCOND_COINSRMINCAP is null");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrmincapIsNotNull() {
            addCriterion("IFCOND_COINSRMINCAP is not null");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrmincapEqualTo(BigDecimal value) {
            addCriterion("IFCOND_COINSRMINCAP =", value, "ifcondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrmincapNotEqualTo(BigDecimal value) {
            addCriterion("IFCOND_COINSRMINCAP <>", value, "ifcondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrmincapGreaterThan(BigDecimal value) {
            addCriterion("IFCOND_COINSRMINCAP >", value, "ifcondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrmincapGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("IFCOND_COINSRMINCAP >=", value, "ifcondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrmincapLessThan(BigDecimal value) {
            addCriterion("IFCOND_COINSRMINCAP <", value, "ifcondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrmincapLessThanOrEqualTo(BigDecimal value) {
            addCriterion("IFCOND_COINSRMINCAP <=", value, "ifcondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrmincapIn(List<BigDecimal> values) {
            addCriterion("IFCOND_COINSRMINCAP in", values, "ifcondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrmincapNotIn(List<BigDecimal> values) {
            addCriterion("IFCOND_COINSRMINCAP not in", values, "ifcondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrmincapBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("IFCOND_COINSRMINCAP between", value1, value2, "ifcondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrmincapNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("IFCOND_COINSRMINCAP not between", value1, value2, "ifcondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapIsNull() {
            addCriterion("IFCOND_COINSRCAP is null");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapIsNotNull() {
            addCriterion("IFCOND_COINSRCAP is not null");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapEqualTo(BigDecimal value) {
            addCriterion("IFCOND_COINSRCAP =", value, "ifcondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapNotEqualTo(BigDecimal value) {
            addCriterion("IFCOND_COINSRCAP <>", value, "ifcondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapGreaterThan(BigDecimal value) {
            addCriterion("IFCOND_COINSRCAP >", value, "ifcondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("IFCOND_COINSRCAP >=", value, "ifcondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapLessThan(BigDecimal value) {
            addCriterion("IFCOND_COINSRCAP <", value, "ifcondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapLessThanOrEqualTo(BigDecimal value) {
            addCriterion("IFCOND_COINSRCAP <=", value, "ifcondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapIn(List<BigDecimal> values) {
            addCriterion("IFCOND_COINSRCAP in", values, "ifcondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapNotIn(List<BigDecimal> values) {
            addCriterion("IFCOND_COINSRCAP not in", values, "ifcondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("IFCOND_COINSRCAP between", value1, value2, "ifcondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("IFCOND_COINSRCAP not between", value1, value2, "ifcondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapFrequencyIsNull() {
            addCriterion("IFCOND_COINSRCAP_FREQUENCY is null");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapFrequencyIsNotNull() {
            addCriterion("IFCOND_COINSRCAP_FREQUENCY is not null");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapFrequencyEqualTo(Short value) {
            addCriterion("IFCOND_COINSRCAP_FREQUENCY =", value, "ifcondCoinsrcapFrequency");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapFrequencyNotEqualTo(Short value) {
            addCriterion("IFCOND_COINSRCAP_FREQUENCY <>", value, "ifcondCoinsrcapFrequency");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapFrequencyGreaterThan(Short value) {
            addCriterion("IFCOND_COINSRCAP_FREQUENCY >", value, "ifcondCoinsrcapFrequency");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapFrequencyGreaterThanOrEqualTo(Short value) {
            addCriterion("IFCOND_COINSRCAP_FREQUENCY >=", value, "ifcondCoinsrcapFrequency");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapFrequencyLessThan(Short value) {
            addCriterion("IFCOND_COINSRCAP_FREQUENCY <", value, "ifcondCoinsrcapFrequency");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapFrequencyLessThanOrEqualTo(Short value) {
            addCriterion("IFCOND_COINSRCAP_FREQUENCY <=", value, "ifcondCoinsrcapFrequency");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapFrequencyIn(List<Short> values) {
            addCriterion("IFCOND_COINSRCAP_FREQUENCY in", values, "ifcondCoinsrcapFrequency");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapFrequencyNotIn(List<Short> values) {
            addCriterion("IFCOND_COINSRCAP_FREQUENCY not in", values, "ifcondCoinsrcapFrequency");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapFrequencyBetween(Short value1, Short value2) {
            addCriterion("IFCOND_COINSRCAP_FREQUENCY between", value1, value2, "ifcondCoinsrcapFrequency");
            return (Criteria) this;
        }

        public Criteria andIfcondCoinsrcapFrequencyNotBetween(Short value1, Short value2) {
            addCriterion("IFCOND_COINSRCAP_FREQUENCY not between", value1, value2, "ifcondCoinsrcapFrequency");
            return (Criteria) this;
        }

        public Criteria andIfcondExcessCoinsrcapMaxvalIsNull() {
            addCriterion("IFCOND_EXCESS_COINSRCAP_MAXVAL is null");
            return (Criteria) this;
        }

        public Criteria andIfcondExcessCoinsrcapMaxvalIsNotNull() {
            addCriterion("IFCOND_EXCESS_COINSRCAP_MAXVAL is not null");
            return (Criteria) this;
        }

        public Criteria andIfcondExcessCoinsrcapMaxvalEqualTo(BigDecimal value) {
            addCriterion("IFCOND_EXCESS_COINSRCAP_MAXVAL =", value, "ifcondExcessCoinsrcapMaxval");
            return (Criteria) this;
        }

        public Criteria andIfcondExcessCoinsrcapMaxvalNotEqualTo(BigDecimal value) {
            addCriterion("IFCOND_EXCESS_COINSRCAP_MAXVAL <>", value, "ifcondExcessCoinsrcapMaxval");
            return (Criteria) this;
        }

        public Criteria andIfcondExcessCoinsrcapMaxvalGreaterThan(BigDecimal value) {
            addCriterion("IFCOND_EXCESS_COINSRCAP_MAXVAL >", value, "ifcondExcessCoinsrcapMaxval");
            return (Criteria) this;
        }

        public Criteria andIfcondExcessCoinsrcapMaxvalGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("IFCOND_EXCESS_COINSRCAP_MAXVAL >=", value, "ifcondExcessCoinsrcapMaxval");
            return (Criteria) this;
        }

        public Criteria andIfcondExcessCoinsrcapMaxvalLessThan(BigDecimal value) {
            addCriterion("IFCOND_EXCESS_COINSRCAP_MAXVAL <", value, "ifcondExcessCoinsrcapMaxval");
            return (Criteria) this;
        }

        public Criteria andIfcondExcessCoinsrcapMaxvalLessThanOrEqualTo(BigDecimal value) {
            addCriterion("IFCOND_EXCESS_COINSRCAP_MAXVAL <=", value, "ifcondExcessCoinsrcapMaxval");
            return (Criteria) this;
        }

        public Criteria andIfcondExcessCoinsrcapMaxvalIn(List<BigDecimal> values) {
            addCriterion("IFCOND_EXCESS_COINSRCAP_MAXVAL in", values, "ifcondExcessCoinsrcapMaxval");
            return (Criteria) this;
        }

        public Criteria andIfcondExcessCoinsrcapMaxvalNotIn(List<BigDecimal> values) {
            addCriterion("IFCOND_EXCESS_COINSRCAP_MAXVAL not in", values, "ifcondExcessCoinsrcapMaxval");
            return (Criteria) this;
        }

        public Criteria andIfcondExcessCoinsrcapMaxvalBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("IFCOND_EXCESS_COINSRCAP_MAXVAL between", value1, value2, "ifcondExcessCoinsrcapMaxval");
            return (Criteria) this;
        }

        public Criteria andIfcondExcessCoinsrcapMaxvalNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("IFCOND_EXCESS_COINSRCAP_MAXVAL not between", value1, value2, "ifcondExcessCoinsrcapMaxval");
            return (Criteria) this;
        }

        public Criteria andAndcondTypeIsNull() {
            addCriterion("ANDCOND_TYPE is null");
            return (Criteria) this;
        }

        public Criteria andAndcondTypeIsNotNull() {
            addCriterion("ANDCOND_TYPE is not null");
            return (Criteria) this;
        }

        public Criteria andAndcondTypeEqualTo(String value) {
            addCriterion("ANDCOND_TYPE =", value, "andcondType");
            return (Criteria) this;
        }

        public Criteria andAndcondTypeNotEqualTo(String value) {
            addCriterion("ANDCOND_TYPE <>", value, "andcondType");
            return (Criteria) this;
        }

        public Criteria andAndcondTypeGreaterThan(String value) {
            addCriterion("ANDCOND_TYPE >", value, "andcondType");
            return (Criteria) this;
        }

        public Criteria andAndcondTypeGreaterThanOrEqualTo(String value) {
            addCriterion("ANDCOND_TYPE >=", value, "andcondType");
            return (Criteria) this;
        }

        public Criteria andAndcondTypeLessThan(String value) {
            addCriterion("ANDCOND_TYPE <", value, "andcondType");
            return (Criteria) this;
        }

        public Criteria andAndcondTypeLessThanOrEqualTo(String value) {
            addCriterion("ANDCOND_TYPE <=", value, "andcondType");
            return (Criteria) this;
        }

        public Criteria andAndcondTypeLike(String value) {
            addCriterion("ANDCOND_TYPE like", value, "andcondType");
            return (Criteria) this;
        }

        public Criteria andAndcondTypeNotLike(String value) {
            addCriterion("ANDCOND_TYPE not like", value, "andcondType");
            return (Criteria) this;
        }

        public Criteria andAndcondTypeIn(List<String> values) {
            addCriterion("ANDCOND_TYPE in", values, "andcondType");
            return (Criteria) this;
        }

        public Criteria andAndcondTypeNotIn(List<String> values) {
            addCriterion("ANDCOND_TYPE not in", values, "andcondType");
            return (Criteria) this;
        }

        public Criteria andAndcondTypeBetween(String value1, String value2) {
            addCriterion("ANDCOND_TYPE between", value1, value2, "andcondType");
            return (Criteria) this;
        }

        public Criteria andAndcondTypeNotBetween(String value1, String value2) {
            addCriterion("ANDCOND_TYPE not between", value1, value2, "andcondType");
            return (Criteria) this;
        }

        public Criteria andAndcondGevalIsNull() {
            addCriterion("ANDCOND_GEVAL is null");
            return (Criteria) this;
        }

        public Criteria andAndcondGevalIsNotNull() {
            addCriterion("ANDCOND_GEVAL is not null");
            return (Criteria) this;
        }

        public Criteria andAndcondGevalEqualTo(BigDecimal value) {
            addCriterion("ANDCOND_GEVAL =", value, "andcondGeval");
            return (Criteria) this;
        }

        public Criteria andAndcondGevalNotEqualTo(BigDecimal value) {
            addCriterion("ANDCOND_GEVAL <>", value, "andcondGeval");
            return (Criteria) this;
        }

        public Criteria andAndcondGevalGreaterThan(BigDecimal value) {
            addCriterion("ANDCOND_GEVAL >", value, "andcondGeval");
            return (Criteria) this;
        }

        public Criteria andAndcondGevalGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("ANDCOND_GEVAL >=", value, "andcondGeval");
            return (Criteria) this;
        }

        public Criteria andAndcondGevalLessThan(BigDecimal value) {
            addCriterion("ANDCOND_GEVAL <", value, "andcondGeval");
            return (Criteria) this;
        }

        public Criteria andAndcondGevalLessThanOrEqualTo(BigDecimal value) {
            addCriterion("ANDCOND_GEVAL <=", value, "andcondGeval");
            return (Criteria) this;
        }

        public Criteria andAndcondGevalIn(List<BigDecimal> values) {
            addCriterion("ANDCOND_GEVAL in", values, "andcondGeval");
            return (Criteria) this;
        }

        public Criteria andAndcondGevalNotIn(List<BigDecimal> values) {
            addCriterion("ANDCOND_GEVAL not in", values, "andcondGeval");
            return (Criteria) this;
        }

        public Criteria andAndcondGevalBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("ANDCOND_GEVAL between", value1, value2, "andcondGeval");
            return (Criteria) this;
        }

        public Criteria andAndcondGevalNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("ANDCOND_GEVAL not between", value1, value2, "andcondGeval");
            return (Criteria) this;
        }

        public Criteria andAndcondLevalIsNull() {
            addCriterion("ANDCOND_LEVAL is null");
            return (Criteria) this;
        }

        public Criteria andAndcondLevalIsNotNull() {
            addCriterion("ANDCOND_LEVAL is not null");
            return (Criteria) this;
        }

        public Criteria andAndcondLevalEqualTo(BigDecimal value) {
            addCriterion("ANDCOND_LEVAL =", value, "andcondLeval");
            return (Criteria) this;
        }

        public Criteria andAndcondLevalNotEqualTo(BigDecimal value) {
            addCriterion("ANDCOND_LEVAL <>", value, "andcondLeval");
            return (Criteria) this;
        }

        public Criteria andAndcondLevalGreaterThan(BigDecimal value) {
            addCriterion("ANDCOND_LEVAL >", value, "andcondLeval");
            return (Criteria) this;
        }

        public Criteria andAndcondLevalGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("ANDCOND_LEVAL >=", value, "andcondLeval");
            return (Criteria) this;
        }

        public Criteria andAndcondLevalLessThan(BigDecimal value) {
            addCriterion("ANDCOND_LEVAL <", value, "andcondLeval");
            return (Criteria) this;
        }

        public Criteria andAndcondLevalLessThanOrEqualTo(BigDecimal value) {
            addCriterion("ANDCOND_LEVAL <=", value, "andcondLeval");
            return (Criteria) this;
        }

        public Criteria andAndcondLevalIn(List<BigDecimal> values) {
            addCriterion("ANDCOND_LEVAL in", values, "andcondLeval");
            return (Criteria) this;
        }

        public Criteria andAndcondLevalNotIn(List<BigDecimal> values) {
            addCriterion("ANDCOND_LEVAL not in", values, "andcondLeval");
            return (Criteria) this;
        }

        public Criteria andAndcondLevalBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("ANDCOND_LEVAL between", value1, value2, "andcondLeval");
            return (Criteria) this;
        }

        public Criteria andAndcondLevalNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("ANDCOND_LEVAL not between", value1, value2, "andcondLeval");
            return (Criteria) this;
        }

        public Criteria andElsecondMaxValueIsNull() {
            addCriterion("ELSECOND_MAX_VALUE is null");
            return (Criteria) this;
        }

        public Criteria andElsecondMaxValueIsNotNull() {
            addCriterion("ELSECOND_MAX_VALUE is not null");
            return (Criteria) this;
        }

        public Criteria andElsecondMaxValueEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_MAX_VALUE =", value, "elsecondMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondMaxValueNotEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_MAX_VALUE <>", value, "elsecondMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondMaxValueGreaterThan(BigDecimal value) {
            addCriterion("ELSECOND_MAX_VALUE >", value, "elsecondMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondMaxValueGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_MAX_VALUE >=", value, "elsecondMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondMaxValueLessThan(BigDecimal value) {
            addCriterion("ELSECOND_MAX_VALUE <", value, "elsecondMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondMaxValueLessThanOrEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_MAX_VALUE <=", value, "elsecondMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondMaxValueIn(List<BigDecimal> values) {
            addCriterion("ELSECOND_MAX_VALUE in", values, "elsecondMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondMaxValueNotIn(List<BigDecimal> values) {
            addCriterion("ELSECOND_MAX_VALUE not in", values, "elsecondMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondMaxValueBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("ELSECOND_MAX_VALUE between", value1, value2, "elsecondMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondMaxValueNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("ELSECOND_MAX_VALUE not between", value1, value2, "elsecondMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondDependentMaxValueIsNull() {
            addCriterion("ELSECOND_DEPENDENT_MAX_VALUE is null");
            return (Criteria) this;
        }

        public Criteria andElsecondDependentMaxValueIsNotNull() {
            addCriterion("ELSECOND_DEPENDENT_MAX_VALUE is not null");
            return (Criteria) this;
        }

        public Criteria andElsecondDependentMaxValueEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_DEPENDENT_MAX_VALUE =", value, "elsecondDependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondDependentMaxValueNotEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_DEPENDENT_MAX_VALUE <>", value, "elsecondDependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondDependentMaxValueGreaterThan(BigDecimal value) {
            addCriterion("ELSECOND_DEPENDENT_MAX_VALUE >", value, "elsecondDependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondDependentMaxValueGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_DEPENDENT_MAX_VALUE >=", value, "elsecondDependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondDependentMaxValueLessThan(BigDecimal value) {
            addCriterion("ELSECOND_DEPENDENT_MAX_VALUE <", value, "elsecondDependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondDependentMaxValueLessThanOrEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_DEPENDENT_MAX_VALUE <=", value, "elsecondDependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondDependentMaxValueIn(List<BigDecimal> values) {
            addCriterion("ELSECOND_DEPENDENT_MAX_VALUE in", values, "elsecondDependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondDependentMaxValueNotIn(List<BigDecimal> values) {
            addCriterion("ELSECOND_DEPENDENT_MAX_VALUE not in", values, "elsecondDependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondDependentMaxValueBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("ELSECOND_DEPENDENT_MAX_VALUE between", value1, value2, "elsecondDependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondDependentMaxValueNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("ELSECOND_DEPENDENT_MAX_VALUE not between", value1, value2, "elsecondDependentMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondFamilyMaxValueIsNull() {
            addCriterion("ELSECOND_FAMILY_MAX_VALUE is null");
            return (Criteria) this;
        }

        public Criteria andElsecondFamilyMaxValueIsNotNull() {
            addCriterion("ELSECOND_FAMILY_MAX_VALUE is not null");
            return (Criteria) this;
        }

        public Criteria andElsecondFamilyMaxValueEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_FAMILY_MAX_VALUE =", value, "elsecondFamilyMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondFamilyMaxValueNotEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_FAMILY_MAX_VALUE <>", value, "elsecondFamilyMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondFamilyMaxValueGreaterThan(BigDecimal value) {
            addCriterion("ELSECOND_FAMILY_MAX_VALUE >", value, "elsecondFamilyMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondFamilyMaxValueGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_FAMILY_MAX_VALUE >=", value, "elsecondFamilyMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondFamilyMaxValueLessThan(BigDecimal value) {
            addCriterion("ELSECOND_FAMILY_MAX_VALUE <", value, "elsecondFamilyMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondFamilyMaxValueLessThanOrEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_FAMILY_MAX_VALUE <=", value, "elsecondFamilyMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondFamilyMaxValueIn(List<BigDecimal> values) {
            addCriterion("ELSECOND_FAMILY_MAX_VALUE in", values, "elsecondFamilyMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondFamilyMaxValueNotIn(List<BigDecimal> values) {
            addCriterion("ELSECOND_FAMILY_MAX_VALUE not in", values, "elsecondFamilyMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondFamilyMaxValueBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("ELSECOND_FAMILY_MAX_VALUE between", value1, value2, "elsecondFamilyMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondFamilyMaxValueNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("ELSECOND_FAMILY_MAX_VALUE not between", value1, value2, "elsecondFamilyMaxValue");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrmincapIsNull() {
            addCriterion("ELSECOND_COINSRMINCAP is null");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrmincapIsNotNull() {
            addCriterion("ELSECOND_COINSRMINCAP is not null");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrmincapEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_COINSRMINCAP =", value, "elsecondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrmincapNotEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_COINSRMINCAP <>", value, "elsecondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrmincapGreaterThan(BigDecimal value) {
            addCriterion("ELSECOND_COINSRMINCAP >", value, "elsecondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrmincapGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_COINSRMINCAP >=", value, "elsecondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrmincapLessThan(BigDecimal value) {
            addCriterion("ELSECOND_COINSRMINCAP <", value, "elsecondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrmincapLessThanOrEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_COINSRMINCAP <=", value, "elsecondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrmincapIn(List<BigDecimal> values) {
            addCriterion("ELSECOND_COINSRMINCAP in", values, "elsecondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrmincapNotIn(List<BigDecimal> values) {
            addCriterion("ELSECOND_COINSRMINCAP not in", values, "elsecondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrmincapBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("ELSECOND_COINSRMINCAP between", value1, value2, "elsecondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrmincapNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("ELSECOND_COINSRMINCAP not between", value1, value2, "elsecondCoinsrmincap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrcapIsNull() {
            addCriterion("ELSECOND_COINSRCAP is null");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrcapIsNotNull() {
            addCriterion("ELSECOND_COINSRCAP is not null");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrcapEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_COINSRCAP =", value, "elsecondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrcapNotEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_COINSRCAP <>", value, "elsecondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrcapGreaterThan(BigDecimal value) {
            addCriterion("ELSECOND_COINSRCAP >", value, "elsecondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrcapGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_COINSRCAP >=", value, "elsecondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrcapLessThan(BigDecimal value) {
            addCriterion("ELSECOND_COINSRCAP <", value, "elsecondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrcapLessThanOrEqualTo(BigDecimal value) {
            addCriterion("ELSECOND_COINSRCAP <=", value, "elsecondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrcapIn(List<BigDecimal> values) {
            addCriterion("ELSECOND_COINSRCAP in", values, "elsecondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrcapNotIn(List<BigDecimal> values) {
            addCriterion("ELSECOND_COINSRCAP not in", values, "elsecondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrcapBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("ELSECOND_COINSRCAP between", value1, value2, "elsecondCoinsrcap");
            return (Criteria) this;
        }

        public Criteria andElsecondCoinsrcapNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("ELSECOND_COINSRCAP not between", value1, value2, "elsecondCoinsrcap");
            return (Criteria) this;
        }
    }

    public static class Criteria extends GeneratedCriteria {

        protected Criteria() {
            super();
        }
    }

    public static class Criterion {
        private String condition;

        private Object value;

        private Object secondValue;

        private boolean noValue;

        private boolean singleValue;

        private boolean betweenValue;

        private boolean listValue;

        private String typeHandler;

        public String getCondition() {
            return condition;
        }

        public Object getValue() {
            return value;
        }

        public Object getSecondValue() {
            return secondValue;
        }

        public boolean isNoValue() {
            return noValue;
        }

        public boolean isSingleValue() {
            return singleValue;
        }

        public boolean isBetweenValue() {
            return betweenValue;
        }

        public boolean isListValue() {
            return listValue;
        }

        public String getTypeHandler() {
            return typeHandler;
        }

        protected Criterion(String condition) {
            super();
            this.condition = condition;
            this.typeHandler = null;
            this.noValue = true;
        }

        protected Criterion(String condition, Object value, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.typeHandler = typeHandler;
            if (value instanceof List<?>) {
                this.listValue = true;
            } else {
                this.singleValue = true;
            }
        }

        protected Criterion(String condition, Object value) {
            this(condition, value, null);
        }

        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.secondValue = secondValue;
            this.typeHandler = typeHandler;
            this.betweenValue = true;
        }

        protected Criterion(String condition, Object value, Object secondValue) {
            this(condition, value, secondValue, null);
        }
    }
}